package com.example.demo.demoOne.testOne;

import com.example.demo.demoOne.impl.NoReturnNoParamImpl;
import com.example.demo.demoOne.inter.*;

public class Test1 {


    //语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。
    public static void main(String[] args) {
        //无返回值无参数的情况
        //1.写一个类去继承接口，然后在调用方法
        NoReturnNoParamImpl noReturnNoParam1 = new NoReturnNoParamImpl();
        noReturnNoParam1.method();

        //2.用匿名内部类去实现简单的接口,
        // 当接口只有一个方法时用匿名内部类去实现比较简单，就不用再去新建一个类了
        NoReturnNoParam noReturnNoParam = new NoReturnNoParam() {
            public void method() {
                System.out.println("2:aa");
            }

            ;

        };
        noReturnNoParam.method();

        //3.最后用lambda表达式去简化
        NoReturnNoParam param01 = () -> {
            System.out.println("3.这里使用lambda表达式去简化匿名内部类书写方式");
        };
        param01.method();

        //-----其他带参，带返回值的情况

        //4.无返回值，带一个参数
        NoReturnOneParam oneParam = (int a) -> {
            System.out.println("4.无返回值带一个参数:" + a);
        };
        oneParam.method(11);

        //不用写参数类型也可以
       /* NoReturnOneParam oneParam2 = (a)->{
            System.out.println("4.无返回值带一个参数:"+a);
        };
        oneParam2.method(11);*/

        //5.无返回值，带多个参数
        NoReturnMultiParam twoParam = (int a, int b) -> {
            System.out.println("5.无返回值带多个参数:" + a + b);
        };
        twoParam.method(1, 2);
        //不写参数类型也可以
        NoReturnMultiParam threeParam = (int a, int b) -> {
            System.out.println("5.无返回值带多个参数:" + a + b);
        };
        threeParam.method(1, 2);


        //6.有返回值，无参数的情况
        ReturnNoParam fourParam = () -> {
            return 11;
        };
        System.out.println("6.有返回值，无参数的情况:" + fourParam.method());
        //大括号里面只有一行可以省略大括号，有返回值可以省略return
        //6.有返回值，无参数的情况
       /* ReturnNoParam  fiveParam = ()->11;
        System.out.println("6.有返回值，无参数的情况:"+fiveParam.method());*/

        //7.有返回值，带一个参数的情况
        ReturnOneParam sixParam = (int a) -> {
            return a + 11;
        };
        //ReturnOneParam sixParam = a->a+ 11;
        sixParam.method(2);

        //8.有返回值，带多个参数的情况
        ReturnMultiParam sevenParam = (int a, int b) -> {
            return a + b;
        };
        sevenParam.method(1, 2);

        //----表达式简化，
        //1.参数简化：参数类型可以不用写：
        ReturnMultiParam eightParam = (a, b) -> {
            return a + b;
        };
        eightParam.method(1, 2);
        //2.参数简化：一个参数时，参数的括号可以不写
        ReturnOneParam nightParam = a -> {
            return a;
        };
        nightParam.method(1);
        //3.方法体内只有一行的时候可以方法不写大括号
        NoReturnMultiParam tenParam = (a, b) -> System.out.println(a + b);

        //4.方法体内只有一个的时候，
        // 但是方法是有返回值的走起去掉大括号的时候要去掉return;
        ReturnOneParam elevenParam = a -> a;
        elevenParam.method(11);


        //-----


    }

}
